home *** CD-ROM | disk | FTP | other *** search
/ Future Workshop / Future Workshop.iso / multimed / qtw111 / mplayer / movieutl.c < prev    next >
C/C++ Source or Header  |  1994-01-11  |  27KB  |  699 lines
  1.  
  2. // ---------------------------------------------------------------------
  3. //
  4. // MovieUtl.c - Movie Player - QuickTime for Windows
  5. //
  6. //              Version 1.0
  7. //
  8. //              (c) 1988-1992 Apple Computer, Inc. All Rights Reserved.
  9. //
  10. // ---------------------------------------------------------------------
  11.  
  12.  
  13.  
  14. // Includes
  15. // --------
  16. #include <Windows.H> // Required by Windows
  17. #include <qtw.h>     // Interface to QuickTime
  18. #include <qtole.h>   // Interface to qtole dll
  19. #include <string.h>  // Standard "C"
  20.  
  21. #include "common.h" // Interface to common.c
  22.  
  23. #include "player.h"  // Interface to other *.c files
  24. #include "player.hr" // Defines used in *.rc files
  25.  
  26. // Constants
  27. // ---------
  28. #define  OPTIONSPROP   "MovieOptionsProp"
  29.  
  30.  
  31. // typedefs
  32. // --------
  33. typedef struct _tagWORKOPTIONS {
  34.     QTOLE_OPTIONSMOVIE      SaveOptions;
  35.     LPQTOLE_OPTIONSMOVIE    lpOptions;
  36.     HLOCAL                  hmem;
  37.    } WORKOPTIONS;
  38. typedef WORKOPTIONS NEAR * NPWORKOPTIONS;
  39.  
  40.  
  41. // Exported callback functions
  42. // ----------------------------
  43. BOOL __export CALLBACK GetOptionsDlgProc    (HWND, UINT, WPARAM, LPARAM);
  44.  
  45. // Internal Function Declarations
  46. // ------------------------------
  47. static VOID    NEAR    SetDlgForOptions       (HWND, LPQTOLE_OPTIONSMOVIE);
  48. static VOID    NEAR    GetCurrentDlgSettings  (HWND, LPQTOLE_OPTIONSMOVIE);
  49. static VOID    NEAR    SaveOptionsAsDefault   (LPQTOLE_OPTIONSMOVIE);
  50.  
  51.  
  52. // Function: PlayerGetOptions - Opens the options dialog
  53. // --------------------------------------------------------------------
  54. // Parameters: HWND                    hwndParent     HWND of dialog parent
  55. //             LPQTOLE_OPTIONSMOVIE    lpOptions      -> options struct
  56. //
  57. // Returns:    LONG                    0L if OK
  58. // --------------------------------------------------------------------
  59. BOOL FAR PlayerGetOptions( HWND hwndParent, LPQTOLE_OPTIONSMOVIE lpOptions )
  60.  
  61. {
  62.     BOOL         bChangedOptions = FALSE;
  63.     DLGPROC      lpDlgProc;
  64.  
  65.     if( lpDlgProc = (DLGPROC) MakeProcInstance
  66.         ( (FARPROC) GetOptionsDlgProc, PlayerQueryInstance())) {
  67.         bChangedOptions = (BOOL) DialogBoxParam( PlayerQueryResources(),
  68.             MAKEINTRESOURCE( PLAYER_DLG_OPTIONS ),
  69.             hwndParent? hwndParent: GetActiveWindow(),
  70.             lpDlgProc, (LPARAM) lpOptions );
  71.         FreeProcInstance( (FARPROC) lpDlgProc );
  72.  
  73.         // Null hwndParent indicates that dlg was started by qtole message
  74.         // with no open movie. In this case tell QTOle.dll that dialog has
  75.         // been closed. Must do this even if options are not changed and
  76.         // must return the same pointer to lpOptions as input argument to
  77.         // this function. When qtole opens dialog for open movie, normal
  78.         // closing will updata options
  79.         if( !hwndParent )
  80.             QTOLE_ClosedOptionsDlg( PlayerQueryOleData(),
  81.             (LPQTOLE_OPTIONS) lpOptions, bChangedOptions );
  82.     }
  83.     else {
  84.         CommonTellUser( PlayerQueryResources(),
  85.             PLAYER_STRING_NOMEMORY, NULL, MB_OK );
  86.     }
  87.  
  88.     return bChangedOptions;
  89. }
  90.  
  91.  
  92. // Function: GetOptionsDlgProc - Get options dialog proc
  93. // --------------------------------------------------------------------
  94. // Parameters: As required by Microsoft Windows
  95. //
  96. // Returns:    As required by Microsoft Windows
  97. // --------------------------------------------------------------------
  98. BOOL __export CALLBACK GetOptionsDlgProc
  99.     ( HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam )
  100.  
  101. {
  102.     NPWORKOPTIONS           pwoWorkOptions;
  103.     HLOCAL                  hmem;
  104.     BOOL                    bOptionsChanged;
  105.     BOOL                    bChecked;
  106.     LPQTOLE_OPTIONSMOVIE    lpOptions;
  107.  
  108.     switch( message ) {
  109.         case WM_INITDIALOG:
  110.             lpOptions = (LPQTOLE_OPTIONSMOVIE) lParam;
  111.  
  112.             hmem = LocalAlloc( LHND, sizeof( WORKOPTIONS ));
  113.             pwoWorkOptions = (NPWORKOPTIONS) LocalLock( hmem );
  114.             pwoWorkOptions->hmem = hmem;
  115.             pwoWorkOptions->SaveOptions = *lpOptions;
  116.             pwoWorkOptions->lpOptions   = lpOptions;
  117.  
  118.             SetProp( hdlg, OPTIONSPROP, (HANDLE) pwoWorkOptions );
  119.  
  120.             SetDlgForOptions( hdlg, pwoWorkOptions->lpOptions );
  121.  
  122.             SetDlgItemText( hdlg, EDIT_OPTIONS_CAPTION,
  123.                 pwoWorkOptions->lpOptions->szCaption );
  124.  
  125.             return TRUE;
  126.  
  127.         case WM_COMMAND:
  128.             switch( wParam  ) {
  129.                 case IDOK:
  130.                     pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  131.                     GetCurrentDlgSettings( hdlg, pwoWorkOptions->lpOptions );
  132.  
  133.                     bOptionsChanged
  134.                         = (_fmemcmp( pwoWorkOptions->lpOptions,
  135.                         &pwoWorkOptions->SaveOptions,
  136.                         sizeof( QTOLE_OPTIONSMOVIE )) != 0 );
  137.                     hmem = pwoWorkOptions->hmem;
  138.                     LocalUnlock( hmem );
  139.                     LocalFree( hmem );
  140.                     RemoveProp( hdlg, OPTIONSPROP );
  141.  
  142.                     EndDialog( hdlg, bOptionsChanged );
  143.                     return TRUE;
  144.  
  145.                 case IDCANCEL:
  146.                     pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  147.                     hmem = pwoWorkOptions->hmem;
  148.                     LocalUnlock( hmem );
  149.                     LocalFree( hmem );
  150.                     RemoveProp( hdlg, OPTIONSPROP );
  151.  
  152.                     EndDialog( hdlg, FALSE  );
  153.                     return TRUE;
  154.  
  155.                 case EDIT_OPTIONS_SHOWMC:
  156.                     bChecked = IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SHOWMC );
  157.                     EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION_TEXT ),
  158.                         bChecked );
  159.                     EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION ),
  160.                         bChecked );
  161.                     return TRUE;
  162.  
  163.                 case EDIT_OPTIONS_COPYICON:
  164.                     bChecked = IsDlgButtonChecked( hdlg, EDIT_OPTIONS_COPYICON );
  165.                     EnableWindow( GetDlgItem( hdlg,
  166.                         EDIT_OPTIONS_SHOWTITLEBAR ), bChecked );
  167.                     if( !bChecked )
  168.                         CheckDlgButton( hdlg, EDIT_OPTIONS_SHOWTITLEBAR, TRUE );
  169.                     return TRUE;
  170.  
  171.                 case EDIT_OPTIONS_SAVEASDEF:
  172.                     pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  173.                     GetCurrentDlgSettings( hdlg, pwoWorkOptions->lpOptions );
  174.                     SaveOptionsAsDefault( pwoWorkOptions->lpOptions );
  175.                     return TRUE;
  176.  
  177.                 case EDIT_OPTIONS_RESTRDEF:
  178.                     pwoWorkOptions = (NPWORKOPTIONS) GetProp( hdlg, OPTIONSPROP );
  179.                     PlayerGetDefaultOptions( pwoWorkOptions->lpOptions );
  180.                     SetDlgForOptions( hdlg, pwoWorkOptions->lpOptions );
  181.                     return FALSE;
  182.  
  183.                 default:
  184.                     return FALSE;
  185.             }
  186.             return TRUE;
  187.  
  188.         default:
  189.             return FALSE;
  190.     }
  191.  
  192.     return FALSE;
  193. }
  194.  
  195.  
  196. // Function: QTOLEServerCallBack - Server callback used by qtole.dll to
  197. //                                 send commands to the server
  198. // --------------------------------------------------------------------
  199. // Parameters: UINT                      uMessage
  200. //             WPARAM                    wParam
  201. //             LPARAM                    lParam
  202. //             LPQTOLE_OPTIONSMOVIE      lpOptions
  203. //
  204. //
  205. // Returns:    QTOLE_ERR        QTOLE_OK if OK
  206. // --------------------------------------------------------------------
  207. QTOLE_ERR __export CALLBACK QTOLEServerCallBack
  208.     ( UINT uMessage, WPARAM wParam, LPARAM lParam,
  209.     LPQTOLE_OPTIONSMOVIE lpOptions )
  210.  
  211. {
  212.     HWND           hwndMovie;
  213.     NPMOVIEDATA    pMovieData;
  214.     RECT           rcMovie;
  215.     RECT           rcClient;
  216.     RECT           rcIntersect;
  217.  
  218.  
  219.     switch( uMessage ) {
  220.         case QTOLE_MSG_OPENOBJECT:
  221.             // Open a movie window
  222.             SendMessage( PlayerQueryFrameWindow(),
  223.                 WM_PLAYER_CMDLINE, 0, lParam );
  224.             hwndMovie = (HWND) SendMessage( PlayerQueryClientWindow(),
  225.                 WM_MDIGETACTIVE, 0, 0L );
  226.  
  227.             if( hwndMovie &&
  228.                 ( pMovieData = (NPMOVIEDATA) GetWindowWord( hwndMovie, 0 ))) {
  229.                 pMovieData->qtoleOptions = *lpOptions;
  230.                 pMovieData->qtoleOptions.hwndObject = hwndMovie;
  231.                 pMovieData->qtoleOptions.mMovie     = pMovieData->mMovie;
  232.                 UpdateMovieForOptions( hwndMovie, pMovieData, TRUE );
  233.             }
  234.  
  235.             break;
  236.  
  237.         case QTOLE_MSG_SHOWOBJECT:
  238.             hwndMovie = (HWND) wParam;
  239.  
  240.             ShowWindow( PlayerQueryFrameWindow(), SW_SHOWNORMAL );
  241.  
  242.             GetWindowRect( hwndMovie, &rcMovie );
  243.             MapWindowPoints( HWND_DESKTOP,
  244.                 PlayerQueryClientWindow(), (LPPOINT) &rcMovie, 2 );
  245.             GetClientRect( PlayerQueryClientWindow(), &rcClient );
  246.             if( !IntersectRect( &rcIntersect, &rcClient, &rcMovie )) {
  247.                 MoveWindow( hwndMovie, 0, 0,
  248.                     rcMovie.right - rcMovie.left,
  249.                     rcMovie.bottom - rcMovie.top, TRUE );
  250.             }
  251.  
  252.             SendMessage( PlayerQueryClientWindow(),
  253.                 WM_MDIACTIVATE, wParam, 0L );
  254.  
  255.             if( pMovieData = (NPMOVIEDATA) GetWindowWord( hwndMovie, 0 )) {
  256.                 pMovieData->qtoleOptions = *lpOptions;
  257.                 pMovieData->qtoleOptions.hwndObject = hwndMovie;
  258.                 pMovieData->qtoleOptions.mMovie     = pMovieData->mMovie;
  259.                 UpdateMovieForOptions( hwndMovie, pMovieData, TRUE );
  260.             }
  261.  
  262.             break;
  263.  
  264.         case QTOLE_MSG_OPENOPTIONSDLG:
  265.             // Post message because we are not allowed to open a dialog
  266.             // inside an OLE method, in this case DoVerb which sends this message.
  267.             // In fact, opening the dialog directly seems to work but this
  268.             // is probably just lucky coincidence and can't be counted on.
  269.             // If wParam == hwndMovie is NULL, post to frame wnd because we don't
  270.             // open a movie wnd. If wParam != NULL, post message to hwndMovie to
  271.             // open the dialog
  272.  
  273.             if( NULL != ( hwndMovie = (HWND) wParam )) {
  274.                 PostMessage( hwndMovie, WM_COMMAND, PLAYER_EDIT_OPTIONS, 0L );
  275.             }
  276.             else {
  277.                 PostMessage( PlayerQueryFrameWindow(),
  278.                     WM_PLAYER_OLE_OPTIONSDLG, 0, (LPARAM) lpOptions );
  279.             }
  280.  
  281.             break;
  282.  
  283.         case QTOLE_MSG_PLAYOBJECT:
  284.             PostMessage( PlayerQueryFrameWindow(),
  285.                 WM_PLAYER_OLE_PLAYOBJECT, 0, lParam );
  286.             break;
  287.  
  288.         case QTOLE_MSG_FILEOPEN:
  289.             PostMessage( PlayerQueryFrameWindow(),
  290.                 WM_COMMAND, PLAYER_FILE_OPEN, 0L );
  291.             break;
  292.  
  293.         default:
  294.             return QTOLE_GEN_ERROR;
  295.     }
  296.  
  297.     return QTOLE_OK;
  298. }
  299.  
  300.  
  301. // Function: PlayerGetDefaultOptions - Gets the default options
  302. // --------------------------------------------------------------------
  303. // Parameters: LPQTOLE_OPTIONSMOVIE      lpOptions
  304. //
  305. // Returns:    VOID
  306. // --------------------------------------------------------------------
  307. VOID FAR PlayerGetDefaultOptions( LPQTOLE_OPTIONSMOVIE lpOptions )
  308.  
  309. {
  310.     char      szSection[32];
  311.     char      szEntry[64];
  312.  
  313.     // Initial defaults
  314.     #define SHOWMC_DEF         TRUE
  315.     #define SELONLY_DEF        FALSE
  316.     #define DRAWFRAME_DEF      TRUE
  317.     #define USEPALETTE_DEF     TRUE
  318.     #define COPYICON_DEF       FALSE
  319.     #define SHOWTITLE_DEF      TRUE
  320.     #define CURRENTFRAME_DEF   TRUE
  321.     #define LOOP_DEF           FALSE
  322.     #define LOOPPALIND_DEF     FALSE
  323.     #define SIZEHALF_DEF       FALSE
  324.     #define SIZENORMAL_DEF     TRUE
  325.     #define SIZEDOUBLE_DEF     FALSE
  326.  
  327.     LoadString( PlayerQueryResources(),
  328.         PLAYER_STRING_OPTIONS_NAME, szSection, sizeof( szSection ));
  329.  
  330.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  331.         PLAYER_STRING_OPTIONS_SHOWMC, szEntry, sizeof( szEntry )))
  332.         lpOptions->bShowMovieController = SHOWMC_DEF;
  333.     else
  334.         lpOptions->bShowMovieController = (BOOL)
  335.         GetPrivateProfileInt( szSection, szEntry, SHOWMC_DEF, QTW_PROFILE );
  336.  
  337.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  338.         PLAYER_STRING_OPTIONS_PLAYSELONLY, szEntry, sizeof( szEntry )))
  339.         lpOptions->bPlaySelectionOnly = SELONLY_DEF;
  340.     else
  341.         lpOptions->bPlaySelectionOnly = (BOOL)
  342.         GetPrivateProfileInt( szSection, szEntry, SELONLY_DEF, QTW_PROFILE );
  343.  
  344.     if( lpOptions->bSoundOnlyMovie )
  345.         lpOptions->bDrawWindowFrame = FALSE;
  346.     else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  347.         PLAYER_STRING_OPTIONS_DRAWFRAME, szEntry, sizeof( szEntry )))
  348.         lpOptions->bDrawWindowFrame = DRAWFRAME_DEF;
  349.     else
  350.         lpOptions->bDrawWindowFrame = (BOOL)
  351.         GetPrivateProfileInt( szSection, szEntry, DRAWFRAME_DEF, QTW_PROFILE );
  352.  
  353.     if( lpOptions->bSoundOnlyMovie )
  354.         lpOptions->bUseMoviePalette = FALSE;
  355.     else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  356.         PLAYER_STRING_OPTIONS_USEPALETTE, szEntry, sizeof( szEntry )))
  357.         lpOptions->bUseMoviePalette = USEPALETTE_DEF;
  358.     else
  359.         lpOptions->bUseMoviePalette = (BOOL)
  360.         GetPrivateProfileInt( szSection, szEntry, USEPALETTE_DEF, QTW_PROFILE );
  361.  
  362.  
  363.     if( lpOptions->bSoundOnlyMovie )
  364.         lpOptions->bCopyIcon = TRUE;
  365.     else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  366.         PLAYER_STRING_OPTIONS_COPYICON, szEntry, sizeof( szEntry )))
  367.         lpOptions->bCopyIcon = COPYICON_DEF;
  368.     else
  369.         lpOptions->bCopyIcon = (BOOL)
  370.         GetPrivateProfileInt( szSection, szEntry, COPYICON_DEF, QTW_PROFILE );
  371.  
  372.  
  373.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  374.         PLAYER_STRING_OPTIONS_SHOWTITLE, szEntry, sizeof( szEntry )))
  375.         lpOptions->bShowTitleBar = SHOWTITLE_DEF;
  376.     else
  377.         lpOptions->bShowTitleBar = (BOOL)
  378.         GetPrivateProfileInt( szSection, szEntry, SHOWTITLE_DEF, QTW_PROFILE );
  379.  
  380.  
  381.     if( lpOptions->bSoundOnlyMovie )                     // This actually doesn't do anything
  382.         lpOptions->bCopyCurrentFrame = CURRENTFRAME_DEF; // for sound only movies
  383.     else if( !szSection[0] || !LoadString( PlayerQueryResources(),
  384.         PLAYER_STRING_OPTIONS_CURRENTFRAME, szEntry, sizeof( szEntry )))
  385.         lpOptions->bCopyCurrentFrame = CURRENTFRAME_DEF;
  386.     else
  387.         lpOptions->bCopyCurrentFrame = (BOOL)
  388.         GetPrivateProfileInt( szSection, szEntry, CURRENTFRAME_DEF, QTW_PROFILE );
  389.  
  390.  
  391.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  392.         PLAYER_STRING_OPTIONS_LOOP, szEntry, sizeof( szEntry )))
  393.         lpOptions->bLoop = LOOP_DEF;
  394.     else
  395.         lpOptions->bLoop = (BOOL)
  396.         GetPrivateProfileInt( szSection, szEntry, LOOP_DEF, QTW_PROFILE );
  397.  
  398.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  399.         PLAYER_STRING_OPTIONS_LOOPPALIND, szEntry, sizeof( szEntry )))
  400.         lpOptions->bLoopPalindrome = LOOPPALIND_DEF;
  401.     else
  402.         lpOptions->bLoopPalindrome = (BOOL)
  403.         GetPrivateProfileInt( szSection, szEntry, LOOPPALIND_DEF, QTW_PROFILE );
  404.  
  405.     // Now make sure only one option is on
  406.     if( lpOptions->bLoop ) {
  407.         lpOptions->bLoopPalindrome = FALSE;
  408.     }
  409.  
  410.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  411.         PLAYER_STRING_OPTIONS_SIZEHALF, szEntry, sizeof( szEntry )))
  412.         lpOptions->bSizeHalf = SIZEHALF_DEF;
  413.     else
  414.         lpOptions->bSizeHalf = (BOOL)
  415.         GetPrivateProfileInt( szSection, szEntry, SIZEHALF_DEF, QTW_PROFILE );
  416.  
  417.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  418.         PLAYER_STRING_OPTIONS_SIZENORMAL, szEntry, sizeof( szEntry )))
  419.         lpOptions->bSizeNormal = SIZENORMAL_DEF;
  420.     else
  421.         lpOptions->bSizeNormal = (BOOL)
  422.         GetPrivateProfileInt( szSection, szEntry, SIZENORMAL_DEF, QTW_PROFILE );
  423.  
  424.     if( !szSection[0] || !LoadString( PlayerQueryResources(),
  425.         PLAYER_STRING_OPTIONS_SIZEDOUBLE, szEntry, sizeof( szEntry )))
  426.         lpOptions->bSizeDouble = SIZEDOUBLE_DEF;
  427.     else
  428.         lpOptions->bSizeDouble = (BOOL)
  429.         GetPrivateProfileInt( szSection, szEntry, SIZEDOUBLE_DEF, QTW_PROFILE );
  430.  
  431.     // Now make sure no more than one option is on
  432.     // Give priority to normal
  433.     if( lpOptions->bSizeNormal ) {
  434.         lpOptions->bSizeHalf   = FALSE;
  435.         lpOptions->bSizeDouble = FALSE;
  436.     }
  437.     else if( lpOptions->bSizeDouble ) {
  438.         lpOptions->bSizeHalf = FALSE;
  439.     }
  440.  
  441.     return;
  442. }
  443.  
  444.  
  445. // Function: SaveOptionsAsDefault - Caches the current options as the defaults
  446. //                                  in qtw.ini
  447. // --------------------------------------------------------------------
  448. // Parameters: LPQTOLE_OPTIONSMOVIE      lpOptions
  449. //
  450. // Returns:    VOID
  451. // --------------------------------------------------------------------
  452. static VOID NEAR SaveOptionsAsDefault( LPQTOLE_OPTIONSMOVIE lpOptions )
  453.  
  454. {
  455.     char      szSection[32];
  456.     char      szEntry[64];
  457.  
  458.     #define szONE     "1"
  459.     #define szZERO    "0"
  460.  
  461.     if( !LoadString( PlayerQueryResources(),
  462.         PLAYER_STRING_OPTIONS_NAME, szSection, sizeof( szSection )))
  463.         return;
  464.  
  465.     if( LoadString( PlayerQueryResources(),
  466.         PLAYER_STRING_OPTIONS_SHOWMC, szEntry, sizeof( szEntry )))
  467.         WritePrivateProfileString( szSection, szEntry,
  468.         lpOptions->bShowMovieController? szONE: szZERO, QTW_PROFILE );
  469.  
  470.     if( LoadString( PlayerQueryResources(),
  471.         PLAYER_STRING_OPTIONS_PLAYSELONLY, szEntry, sizeof( szEntry )))
  472.         WritePrivateProfileString( szSection, szEntry,
  473.         lpOptions->bPlaySelectionOnly? szONE: szZERO, QTW_PROFILE );
  474.  
  475.     if( !lpOptions->bSoundOnlyMovie ) {
  476.         if( LoadString( PlayerQueryResources(),
  477.             PLAYER_STRING_OPTIONS_DRAWFRAME, szEntry, sizeof( szEntry )))
  478.             WritePrivateProfileString( szSection, szEntry,
  479.             lpOptions->bDrawWindowFrame? szONE: szZERO, QTW_PROFILE );
  480.  
  481.         if( LoadString( PlayerQueryResources(),
  482.             PLAYER_STRING_OPTIONS_USEPALETTE, szEntry, sizeof( szEntry )))
  483.             WritePrivateProfileString( szSection, szEntry,
  484.             lpOptions->bUseMoviePalette? szONE: szZERO, QTW_PROFILE );
  485.  
  486.         if( LoadString( PlayerQueryResources(),
  487.             PLAYER_STRING_OPTIONS_COPYICON, szEntry, sizeof( szEntry )))
  488.             WritePrivateProfileString( szSection, szEntry,
  489.             lpOptions->bCopyIcon? szONE: szZERO, QTW_PROFILE );
  490.     }
  491.  
  492.     if( LoadString( PlayerQueryResources(),
  493.         PLAYER_STRING_OPTIONS_SHOWTITLE, szEntry, sizeof( szEntry )))
  494.         WritePrivateProfileString( szSection, szEntry,
  495.         lpOptions->bShowTitleBar? szONE: szZERO, QTW_PROFILE );
  496.  
  497.     if( !lpOptions->bSoundOnlyMovie &&
  498.         LoadString( PlayerQueryResources(),
  499.         PLAYER_STRING_OPTIONS_CURRENTFRAME, szEntry, sizeof( szEntry )))
  500.         WritePrivateProfileString( szSection, szEntry,
  501.         lpOptions->bCopyCurrentFrame? szONE: szZERO, QTW_PROFILE );
  502.  
  503.  
  504.     if( LoadString( PlayerQueryResources(),
  505.         PLAYER_STRING_OPTIONS_LOOP, szEntry, sizeof( szEntry )))
  506.         WritePrivateProfileString( szSection, szEntry,
  507.         lpOptions->bLoop? szONE: szZERO, QTW_PROFILE );
  508.  
  509.     if( LoadString( PlayerQueryResources(),
  510.         PLAYER_STRING_OPTIONS_LOOPPALIND, szEntry, sizeof( szEntry )))
  511.         WritePrivateProfileString( szSection, szEntry,
  512.         lpOptions->bLoopPalindrome? szONE: szZERO, QTW_PROFILE );
  513.  
  514.     if( !lpOptions->bSoundOnlyMovie ) {
  515.         if( LoadString( PlayerQueryResources(),
  516.             PLAYER_STRING_OPTIONS_SIZEHALF, szEntry, sizeof( szEntry )))
  517.             WritePrivateProfileString( szSection, szEntry,
  518.             lpOptions->bSizeHalf? szONE: szZERO, QTW_PROFILE );
  519.  
  520.         if( LoadString( PlayerQueryResources(),
  521.             PLAYER_STRING_OPTIONS_SIZENORMAL, szEntry, sizeof( szEntry )))
  522.             WritePrivateProfileString( szSection, szEntry,
  523.             lpOptions->bSizeNormal? szONE: szZERO, QTW_PROFILE );
  524.  
  525.         if( LoadString( PlayerQueryResources(),
  526.             PLAYER_STRING_OPTIONS_SIZEDOUBLE, szEntry, sizeof( szEntry )))
  527.             WritePrivateProfileString( szSection, szEntry,
  528.             lpOptions->bSizeDouble? szONE: szZERO, QTW_PROFILE );
  529.     }
  530.  
  531.     return;
  532. }
  533.  
  534.  
  535. // Function: SetDlgForOptions - Sets the options dialog controls according
  536. //                              to current options
  537. // --------------------------------------------------------------------
  538. // Parameters: HWND                      hdlg
  539. //             LPQTOLE_OPTIONSMOVIE      lpOptions
  540. //
  541. //
  542. // Returns:    VOID
  543. // --------------------------------------------------------------------
  544. static VOID NEAR SetDlgForOptions( HWND hdlg, LPQTOLE_OPTIONSMOVIE lpOptions )
  545.  
  546. {
  547.     BOOL      bCopyIcon;
  548.     int       idButton;
  549.  
  550.  
  551.     CheckDlgButton( hdlg, EDIT_OPTIONS_SHOWMC,
  552.         lpOptions->bShowMovieController );
  553.  
  554.     EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION_TEXT ),
  555.         lpOptions->bShowMovieController );
  556.     EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_CAPTION ),
  557.         lpOptions->bShowMovieController );
  558.  
  559.     CheckDlgButton( hdlg, EDIT_OPTIONS_PLAYSELONLY,
  560.         lpOptions->bPlaySelectionOnly );
  561.     if( !lpOptions->bSoundOnlyMovie ) {
  562.         CheckDlgButton( hdlg, EDIT_OPTIONS_DRAWFRAME,
  563.             lpOptions->bDrawWindowFrame );
  564.         CheckDlgButton( hdlg, EDIT_OPTIONS_USEPALETTE,
  565.             lpOptions->bUseMoviePalette );
  566.     }
  567.     else {
  568.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_DRAWFRAME ), FALSE );
  569.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_USEPALETTE ), FALSE );
  570.     }
  571.  
  572.  
  573.     if( !lpOptions->bSoundOnlyMovie ) {
  574.         bCopyIcon = lpOptions->bCopyIcon;
  575.     }
  576.     else {
  577.         bCopyIcon = TRUE;
  578.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_COPYICON ), FALSE );
  579.     }
  580.  
  581.     CheckDlgButton( hdlg, EDIT_OPTIONS_COPYICON, bCopyIcon );
  582.     CheckDlgButton( hdlg, EDIT_OPTIONS_SHOWTITLEBAR, lpOptions->bShowTitleBar );
  583.     if( !bCopyIcon )
  584.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SHOWTITLEBAR ), FALSE );
  585.  
  586.  
  587.     if( !lpOptions->bSoundOnlyMovie ) {
  588.         if( lpOptions->bCopyCurrentFrame )
  589.             idButton = EDIT_OPTIONS_COPYCURRENT;
  590.         else
  591.             idButton = EDIT_OPTIONS_COPYPOSTER;
  592.  
  593.         CheckRadioButton( hdlg, EDIT_OPTIONS_COPYCURRENT,
  594.             EDIT_OPTIONS_COPYPOSTER, idButton );
  595.     }
  596.     else {
  597.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_COPYCURRENT ), FALSE );
  598.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_COPYPOSTER ),  FALSE );
  599.     }
  600.  
  601.     if( lpOptions->bLoop )
  602.         idButton = EDIT_OPTIONS_LOOP;
  603.     else if( lpOptions->bLoopPalindrome )
  604.         idButton = EDIT_OPTIONS_PALINDROME;
  605.     else
  606.         idButton = EDIT_OPTIONS_STOPATEND;
  607.  
  608.     CheckRadioButton( hdlg, EDIT_OPTIONS_STOPATEND,
  609.         EDIT_OPTIONS_PALINDROME, idButton );
  610.  
  611.     if( !lpOptions->bSoundOnlyMovie ) {
  612.         if( lpOptions->bSizeHalf )
  613.             idButton = EDIT_OPTIONS_SIZEHALF;
  614.         else if( lpOptions->bSizeNormal )
  615.             idButton = EDIT_OPTIONS_SIZENORMAL;
  616.         else if( lpOptions->bSizeDouble )
  617.             idButton = EDIT_OPTIONS_SIZEDOUBLE;
  618.         else
  619.             idButton = EDIT_OPTIONS_SIZECURRENT;
  620.  
  621.         CheckRadioButton( hdlg, EDIT_OPTIONS_SIZECURRENT,
  622.             EDIT_OPTIONS_SIZEDOUBLE, idButton );
  623.     }
  624.     else {
  625.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZECURRENT ), FALSE );
  626.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZEHALF ),    FALSE );
  627.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZENORMAL ),  FALSE );
  628.         EnableWindow( GetDlgItem( hdlg, EDIT_OPTIONS_SIZEDOUBLE ),  FALSE );
  629.         CheckRadioButton( hdlg, EDIT_OPTIONS_SIZECURRENT,
  630.             EDIT_OPTIONS_SIZEDOUBLE, EDIT_OPTIONS_SIZECURRENT );
  631.     }
  632.  
  633.     return;
  634. }
  635.  
  636.  
  637. // Function: GetCurrentDlgSettings - Fills the options struct with the current state
  638. //                                   of the dialog controls
  639. // --------------------------------------------------------------------
  640. // Parameters: HWND                      hdlg
  641. //             LPQTOLE_OPTIONSMOVIE      lpOptions
  642. //
  643. //
  644. // Returns:    VOID
  645. // --------------------------------------------------------------------
  646. static VOID NEAR GetCurrentDlgSettings( HWND hdlg, LPQTOLE_OPTIONSMOVIE lpOptions )
  647.  
  648. {
  649.     lpOptions->bShowMovieController =
  650.         IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SHOWMC );
  651.     GetDlgItemText( hdlg, EDIT_OPTIONS_CAPTION,
  652.         lpOptions->szCaption, MAX_TEXT_LEN );
  653.     lpOptions->bPlaySelectionOnly =
  654.         IsDlgButtonChecked( hdlg, EDIT_OPTIONS_PLAYSELONLY );
  655.  
  656.     if( !lpOptions->bSoundOnlyMovie ) {
  657.         lpOptions->bDrawWindowFrame =
  658.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_DRAWFRAME );
  659.         lpOptions->bUseMoviePalette =
  660.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_USEPALETTE );
  661.  
  662.         lpOptions->bCopyIcon =
  663.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_COPYICON );
  664.         lpOptions->bShowTitleBar =
  665.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SHOWTITLEBAR );
  666.     }
  667.     else {
  668.         lpOptions->bDrawWindowFrame = FALSE;
  669.         lpOptions->bUseMoviePalette = FALSE;
  670.         lpOptions->bCopyIcon        = TRUE;
  671.         lpOptions->bShowTitleBar    = IsDlgButtonChecked( hdlg,
  672.             EDIT_OPTIONS_SHOWTITLEBAR );
  673.     }
  674.  
  675.     lpOptions->bLoop = IsDlgButtonChecked( hdlg, EDIT_OPTIONS_LOOP );
  676.     lpOptions->bLoopPalindrome =
  677.         IsDlgButtonChecked( hdlg, EDIT_OPTIONS_PALINDROME );
  678.  
  679.     if( !lpOptions->bSoundOnlyMovie ) {
  680.         lpOptions->bSizeHalf =
  681.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SIZEHALF );
  682.         lpOptions->bSizeNormal =
  683.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SIZENORMAL );
  684.         lpOptions->bSizeDouble =
  685.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_SIZEDOUBLE );
  686.  
  687.         lpOptions->bCopyCurrentFrame =
  688.             IsDlgButtonChecked( hdlg, EDIT_OPTIONS_COPYCURRENT );
  689.     }
  690.     else {
  691.         lpOptions->bSizeHalf         = FALSE;
  692.         lpOptions->bSizeNormal       = FALSE;
  693.         lpOptions->bSizeDouble       = FALSE;
  694.         lpOptions->bCopyCurrentFrame = TRUE;
  695.     }
  696.  
  697.     return;
  698. }
  699.